{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 - Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from load_data import load_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From E:\\code\\deeplearning\\手写数字识别\\load_data.py:14: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From c:\\program files (x86)\\microsoft visual studio\\shared\\python36_64\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From c:\\program files (x86)\\microsoft visual studio\\shared\\python36_64\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting datasets/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\program files (x86)\\microsoft visual studio\\shared\\python36_64\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting datasets/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\program files (x86)\\microsoft visual studio\\shared\\python36_64\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting datasets/t10k-images-idx3-ubyte.gz\n",
      "Extracting datasets/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From c:\\program files (x86)\\microsoft visual studio\\shared\\python36_64\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "The shape of train_x is (784, 7000)\n",
      "The shape of train_y is (10, 7000)\n",
      "The shape of test_x is (784, 2000)\n",
      "The shape of test_y is (10, 2000)\n"
     ]
    }
   ],
   "source": [
    "train_x,train_y,test_x,test_y=load_data(7000,2000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 - L-layers initialize parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def init_paras(X,Y,dims):\n",
    "    np.random.seed(0)\n",
    "    paras={}\n",
    "    L=len(dims)\n",
    "    \n",
    "    paras[\"W1\"]=np.random.randn(dims[0],X.shape[0])*0.01\n",
    "    paras[\"b1\"]=np.zeros((dims[0],1))\n",
    "    for l in range(1,L):\n",
    "        paras[\"W\"+str(l+1)]=np.random.randn(dims[l],dims[l-1])*0.01\n",
    "        paras[\"b\"+str(l+1)]=np.zeros((dims[l],1))\n",
    "    paras[\"W\"+str(L+1)]=np.random.randn(Y.shape[0],dims[L-1])*0.01\n",
    "    paras[\"b\"+str(L+1)]=np.zeros((Y.shape[0],1))\n",
    "    return paras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W1 = (1, 784)\n",
      "b1 = (1, 1)\n",
      "W2 = (2, 1)\n",
      "b2 = (2, 1)\n",
      "W3 = (3, 2)\n",
      "b3 = (3, 1)\n",
      "W4 = (4, 3)\n",
      "b4 = (4, 1)\n",
      "W5 = (10, 4)\n",
      "b5 = (10, 1)\n"
     ]
    }
   ],
   "source": [
    "paras=init_paras(train_x,train_y,[1,2,3,4])\n",
    "for l in range(len(paras)//2):\n",
    "    print(\"W\"+str(l+1)+\" = \"+str(paras[\"W\"+str(l+1)].shape))\n",
    "    print(\"b\"+str(l+1)+\" = \"+str(paras[\"b\"+str(l+1)].shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 - L-layers forward propagate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def relu(cache):\n",
    "    A_prev,W,b,Z=cache\n",
    "    return np.maximum(0,Z)\n",
    "def linear_forward(A_prev,W,b):\n",
    "    Z=np.dot(W,A_prev)+b\n",
    "    cache=(A_prev,W,b,Z)\n",
    "    return cache\n",
    "def softmax(cache):\n",
    "    A_prev,W,b,Z=cache\n",
    "    weight=np.exp(Z)\n",
    "    return np.divide(weight,weight.sum(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forward_propagate(X,paras):\n",
    "    L=len(paras)//2\n",
    "    caches=[]\n",
    "    A=X\n",
    "    for l in range(1,L):\n",
    "        cache=linear_forward(A,paras[\"W\"+str(l)],paras[\"b\"+str(l)])\n",
    "        A=relu(cache)\n",
    "        caches.append(cache)\n",
    "    cache=linear_forward(A,paras[\"W\"+str(L)],paras[\"b\"+str(L)])\n",
    "    AL=softmax(cache)\n",
    "    caches.append(cache)\n",
    "    return AL,caches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 - Compute cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(AL,Y):\n",
    "    cost=np.sum(np.multiply(-np.log(AL),Y))/Y.shape[1]\n",
    "    return cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - Backward propagate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_back(dA,cache,lambd):\n",
    "    A_prev,W,b,Z=cache\n",
    "    m=dA.shape[1]\n",
    "    dZ=relu_back(dA,Z)\n",
    "    dW=np.dot(dZ,A_prev.T)/m+lambd*W/m\n",
    "    dA_prev=np.dot(W.T,dZ) \n",
    "    db=np.sum(dZ,axis = 1, keepdims = True)/m\n",
    "    return dW,dA_prev,db\n",
    "def relu_back(dA,Z):\n",
    "    dZ = np.array(dA, copy=True)\n",
    "    dZ[Z <= 0] = 0\n",
    "    return dZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def backward_propagate(X,Y,caches,AL,lambd):\n",
    "    grads={}\n",
    "    L=len(caches)\n",
    "    m=Y.shape[1]\n",
    "    \n",
    "    A_prev,W,b,Z=caches[L-1]\n",
    "    dZL=AL-Y\n",
    "    grads[\"dW\"+str(L)]=np.dot(dZL,A_prev.T)/m+lambd*W/m\n",
    "    grads[\"db\"+str(L)]=np.sum(dZL,axis = 1, keepdims = True)/m\n",
    "    grads[\"dA\"+str(L-1)]=np.dot(W.T,dZL)\n",
    "    \n",
    "    for l in reversed(range(L-1)):\n",
    "        grads[\"dW\"+str(l+1)],grads[\"dA\"+str(l)],grads[\"db\"+str(l+1)]=linear_back(grads[\"dA\"+str(l+1)],caches[l],lambd)\n",
    "    return grads"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6 - Updata paras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updata_paras(paras,grads,learning_rate=0.6):\n",
    "    L=len(paras)//2\n",
    "    for l in range(1,L+1):\n",
    "        paras[\"W\"+str(l)]-=learning_rate*grads[\"dW\"+str(l)]\n",
    "        paras[\"b\"+str(l)]-=learning_rate*grads[\"db\"+str(l)]\n",
    "    return paras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 建立模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(X, Y, layers_dims, lambd,learning_rate = 0.3, num_iterations = 3000, print_cost=True):\n",
    "    costs = []\n",
    "    paras=init_paras(train_x,train_y,layers_dims)\n",
    "    for i in range(0, num_iterations):\n",
    "        AL,caches=forward_propagate(train_x,paras)\n",
    "        cost=compute_cost(AL,train_y)\n",
    "        grads=backward_propagate(train_x,train_y,caches,AL,lambd)\n",
    "        paras=updata_paras(paras,grads,learning_rate)\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "            costs.append(cost)\n",
    "            \n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per tens)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    return paras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X,Y,paras):\n",
    "    AL,_=forward_propagate(X,paras)\n",
    "    m = X.shape[1]\n",
    "\n",
    "    p=AL.argmax(0)\n",
    "    y=Y.argmax(0)\n",
    "    \n",
    "    num=0\n",
    "    for i in range(len(p)):\n",
    "        if p[i]==y[i]:\n",
    "            num+=1\n",
    "    print(\"Accuracy: \"  + str(num*100/m)+\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remodel(paras,X, Y, layers_dims, lambd,learning_rate = 0.3, num_iterations = 3000, print_cost=True):\n",
    "    costs = []\n",
    "    for i in range(0, num_iterations):\n",
    "        AL,caches=forward_propagate(train_x,paras)\n",
    "        cost=compute_cost(AL,train_y)\n",
    "        grads=backward_propagate(train_x,train_y,caches,AL,lambd)\n",
    "        paras=updata_paras(paras,grads,learning_rate)\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "            costs.append(cost)\n",
    "            \n",
    "    plt.plot(np.squeeze(costs))\n",
    "    plt.ylabel('cost')\n",
    "    plt.xlabel('iterations (per tens)')\n",
    "    plt.title(\"Learning rate =\" + str(learning_rate))\n",
    "    plt.show()\n",
    "    return paras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 2.302584\n",
      "Cost after iteration 100: 2.300320\n",
      "Cost after iteration 200: 2.300239\n",
      "Cost after iteration 300: 2.299101\n",
      "Cost after iteration 400: 1.696808\n",
      "Cost after iteration 500: 1.023755\n",
      "Cost after iteration 600: 0.718111\n",
      "Cost after iteration 700: 0.636570\n",
      "Cost after iteration 800: 0.354317\n",
      "Cost after iteration 900: 0.278639\n",
      "Cost after iteration 1000: 0.278662\n",
      "Cost after iteration 1100: 0.215181\n",
      "Cost after iteration 1200: 0.206121\n",
      "Cost after iteration 1300: 0.162178\n",
      "Cost after iteration 1400: 0.150060\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "layers_dims=[10,9]\n",
    "paras=model(train_x, train_y, layers_dims,lambd=2,learning_rate = 0.3,num_iterations = 1500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 继续训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.133552\n",
      "Cost after iteration 100: 0.118853\n",
      "Cost after iteration 200: 0.113735\n",
      "Cost after iteration 300: 0.108972\n",
      "Cost after iteration 400: 0.104513\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "paras=remodel(paras,train_x, train_y, layers_dims,lambd=2,learning_rate = 0.1,num_iterations = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 97.31428571428572%\n"
     ]
    }
   ],
   "source": [
    "pred_train = predict(train_x, train_y, paras)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 88.2%\n"
     ]
    }
   ],
   "source": [
    "pred_test=predict(test_x,test_y,paras)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
